home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / bin / pildriver.py < prev    next >
Text File  |  2009-02-21  |  15KB  |  524 lines
  1. #! /usr/bin/python
  2. """PILdriver, an image-processing calculator using PIL.
  3.  
  4. An instance of class PILDriver is essentially a software stack machine
  5. (Polish-notation interpreter) for sequencing PIL image
  6. transformations.  The state of the instance is the interpreter stack.
  7.  
  8. The only method one will normally invoke after initialization is the
  9. `execute' method.  This takes an argument list of tokens, pushes them
  10. onto the instance's stack, and then tries to clear the stack by
  11. successive evaluation of PILdriver operators.  Any part of the stack
  12. not cleaned off persists and is part of the evaluation context for
  13. the next call of the execute method.
  14.  
  15. PILDriver doesn't catch any exceptions, on the theory that these
  16. are actually diagnostic information that should be interpreted by
  17. the calling code.
  18.  
  19. When called as a script, the command-line arguments are passed to
  20. a PILDriver instance.  If there are no command-line arguments, the
  21. module runs an interactive interpreter, each line of which is split into
  22. space-separated tokens and passed to the execute method.
  23.  
  24. In the method descriptions below, a first line beginning with the string
  25. `usage:' means this method can be invoked with the token that follows
  26. it.  Following <>-enclosed arguments describe how the method interprets
  27. the entries on the stack.  Each argument specification begins with a
  28. type specification: either `int', `float', `string', or `image'.
  29.  
  30. All operations consume their arguments off the stack (use `dup' to
  31. keep copies around).  Use `verbose 1' to see the stack state displayed
  32. before each operation.
  33.  
  34. Usage examples:
  35.  
  36.     `show crop 0 0 200 300 open test.png' loads test.png, crops out a portion
  37. of its upper-left-hand corner and displays the cropped portion.
  38.  
  39.     `save rotated.png rotate 30 open test.tiff' loads test.tiff, rotates it
  40. 30 degrees, and saves the result as rotated.png (in PNG format).
  41. """
  42. # by Eric S. Raymond <esr@thyrsus.com>
  43. # $Id: pildriver.py 2813 2006-10-07 10:11:35Z fredrik $
  44.  
  45. # TO DO:
  46. # 1. Add PILFont capabilities, once that's documented.
  47. # 2. Add PILDraw operations.
  48. # 3. Add support for composing and decomposing multiple-image files.
  49. #
  50.  
  51. import Image, string
  52.  
  53. class PILDriver:
  54.  
  55.     verbose = 0
  56.  
  57.     def do_verbose(self):
  58.         """usage: verbose <int:num>
  59.  
  60.         Set verbosity flag from top of stack.
  61.         """
  62.         self.verbose = self.do_pop()
  63.  
  64.     # The evaluation stack (internal only)
  65.  
  66.     stack = []          # Stack of pending operations
  67.  
  68.     def push(self, item):
  69.         "Push an argument onto the evaluation stack."
  70.         self.stack = [item] + self.stack
  71.  
  72.     def top(self):
  73.         "Return the top-of-stack element."
  74.         return self.stack[0]
  75.  
  76.     # Stack manipulation (callable)
  77.  
  78.     def do_clear(self):
  79.         """usage: clear
  80.  
  81.         Clear the stack.
  82.         """
  83.         self.stack = []
  84.  
  85.     def do_pop(self):
  86.         """usage: pop
  87.  
  88.         Discard the top element on the stack.
  89.         """
  90.         top = self.stack[0]
  91.         self.stack = self.stack[1:]
  92.         return top
  93.  
  94.     def do_dup(self):
  95.         """usage: dup
  96.  
  97.         Duplicate the top-of-stack item.
  98.         """
  99.         if hasattr(self, 'format'):     # If it's an image, do a real copy
  100.             dup = self.stack[0].copy()
  101.         else:
  102.             dup = self.stack[0]
  103.         self.stack = [dup] + self.stack
  104.  
  105.     def do_swap(self):
  106.         """usage: swap
  107.  
  108.         Swap the top-of-stack item with the next one down.
  109.         """
  110.         self.stack = [self.stack[1], self.stack[0]] + self.stack[2:]
  111.  
  112.     # Image module functions (callable)
  113.  
  114.     def do_new(self):
  115.         """usage: new <int:xsize> <int:ysize> <int:color>:
  116.  
  117.         Create and push a greyscale image of given size and color.
  118.         """
  119.         xsize = int(self.do_pop())
  120.         ysize = int(self.do_pop())
  121.         color = int(self.do_pop())
  122.         self.push(Image.new("L", (xsize, ysize), color))
  123.  
  124.     def do_open(self):
  125.         """usage: open <string:filename>
  126.  
  127.         Open the indicated image, read it, push the image on the stack.
  128.         """
  129.         self.push(Image.open(self.do_pop()))
  130.  
  131.     def do_blend(self):
  132.         """usage: blend <image:pic1> <image:pic2> <float:alpha>
  133.  
  134.         Replace two images and an alpha with the blended image.
  135.         """
  136.         image1 = self.do_pop()
  137.         image2 = self.do_pop()
  138.         alpha = float(self.do_pop())
  139.         self.push(Image.blend(image1, image2, alpha))
  140.  
  141.     def do_composite(self):
  142.         """usage: composite <image:pic1> <image:pic2> <image:mask>
  143.  
  144.         Replace two images and a mask with their composite.
  145.         """
  146.         image1 = self.do_pop()
  147.         image2 = self.do_pop()
  148.         mask = self.do_pop()
  149.         self.push(Image.composite(image1, image2, mask))
  150.  
  151.     def do_merge(self):
  152.         """usage: merge <string:mode> <image:pic1> [<image:pic2> [<image:pic3> [<image:pic4>]]]
  153.  
  154.         Merge top-of stack images in a way described by the mode.
  155.         """
  156.         mode = self.do_pop()
  157.         bandlist = []
  158.         for band in mode:
  159.             bandlist.append(self.do_pop())
  160.         self.push(Image.merge(mode, bandlist))
  161.  
  162.     # Image class methods
  163.  
  164.     def do_convert(self):
  165.         """usage: convert <string:mode> <image:pic1>
  166.  
  167.         Convert the top image to the given mode.
  168.         """
  169.         mode = self.do_pop()
  170.         image = self.do_pop()
  171.         self.push(image.convert(mode))
  172.  
  173.     def do_copy(self):
  174.         """usage: copy <image:pic1>
  175.  
  176.         Make and push a true copy of the top image.
  177.         """
  178.         self.dup()
  179.  
  180.     def do_crop(self):
  181.         """usage: crop <int:left> <int:upper> <int:right> <int:lower> <image:pic1>
  182.  
  183.         Crop and push a rectangular region from the current image.
  184.         """
  185.         left = int(self.do_pop())
  186.         upper = int(self.do_pop())
  187.         right = int(self.do_pop())
  188.         lower = int(self.do_pop())
  189.         image = self.do_pop()
  190.         self.push(image.crop((left, upper, right, lower)))
  191.  
  192.     def do_draft(self):
  193.         """usage: draft <string:mode> <int:xsize> <int:ysize>
  194.  
  195.         Configure the loader for a given mode and size.
  196.         """
  197.         mode = self.do_pop()
  198.         xsize = int(self.do_pop())
  199.         ysize = int(self.do_pop())
  200.         self.push(self.draft(mode, (xsize, ysize)))
  201.  
  202.     def do_filter(self):
  203.         """usage: filter <string:filtername> <image:pic1>
  204.  
  205.         Process the top image with the given filter.
  206.         """
  207.         import ImageFilter
  208.         filter = eval("ImageFilter." + string.upper(self.do_pop()))
  209.         image = self.do_pop()
  210.         self.push(image.filter(filter))
  211.  
  212.     def do_getbbox(self):
  213.         """usage: getbbox
  214.  
  215.         Push left, upper, right, and lower pixel coordinates of the top image.
  216.         """
  217.         bounding_box = self.do_pop().getbbox()
  218.         self.push(bounding_box[3])
  219.         self.push(bounding_box[2])
  220.         self.push(bounding_box[1])
  221.         self.push(bounding_box[0])
  222.  
  223.     def do_getextrema(self):
  224.         """usage: extrema
  225.  
  226.         Push minimum and maximum pixel values of the top image.
  227.         """
  228.         extrema = self.do_pop().extrema()
  229.         self.push(extrema[1])
  230.         self.push(extrema[0])
  231.  
  232.     def do_offset(self):
  233.         """usage: offset <int:xoffset> <int:yoffset> <image:pic1>
  234.  
  235.         Offset the pixels in the top image.
  236.         """
  237.         xoff = int(self.do_pop())
  238.         yoff = int(self.do_pop())
  239.         image = self.do_pop()
  240.         self.push(image.offset(xoff, yoff))
  241.  
  242.     def do_paste(self):
  243.         """usage: paste <image:figure> <int:xoffset> <int:yoffset> <image:ground>
  244.  
  245.         Paste figure image into ground with upper left at given offsets.
  246.         """
  247.         figure = self.do_pop()
  248.         xoff = int(self.do_pop())
  249.         yoff = int(self.do_pop())
  250.         ground = self.do_pop()
  251.         if figure.mode == "RGBA":
  252.             ground.paste(figure, (xoff, yoff), figure)
  253.         else:
  254.             ground.paste(figure, (xoff, yoff))
  255.         self.push(ground)
  256.  
  257.     def do_resize(self):
  258.         """usage: resize <int:xsize> <int:ysize> <image:pic1>
  259.  
  260.         Resize the top image.
  261.         """
  262.         ysize = int(self.do_pop())
  263.         xsize = int(self.do_pop())
  264.         image = self.do_pop()
  265.         self.push(image.resize((xsize, ysize)))
  266.  
  267.     def do_rotate(self):
  268.         """usage: rotate <int:angle> <image:pic1>
  269.  
  270.         Rotate image through a given angle
  271.         """
  272.         angle = int(self.do_pop())
  273.         image = self.do_pop()
  274.         self.push(image.rotate(angle))
  275.  
  276.     def do_save(self):
  277.         """usage: save <string:filename> <image:pic1>
  278.  
  279.         Save image with default options.
  280.         """
  281.         filename = self.do_pop()
  282.         image = self.do_pop()
  283.         image.save(filename)
  284.  
  285.     def do_save2(self):
  286.         """usage: save2 <string:filename> <string:options> <image:pic1>
  287.  
  288.         Save image with specified options.
  289.         """
  290.         filename = self.do_pop()
  291.         options = self.do_pop()
  292.         image = self.do_pop()
  293.         image.save(filename, None, options)
  294.  
  295.     def do_show(self):
  296.         """usage: show <image:pic1>
  297.  
  298.         Display and pop the top image.
  299.         """
  300.         self.do_pop().show()
  301.  
  302.     def do_thumbnail(self):
  303.         """usage: thumbnail <int:xsize> <int:ysize> <image:pic1>
  304.  
  305.         Modify the top image in the stack to contain a thumbnail of itself.
  306.         """
  307.         ysize = int(self.do_pop())
  308.         xsize = int(self.do_pop())
  309.         self.top().thumbnail((xsize, ysize))
  310.  
  311.     def do_transpose(self):
  312.         """usage: transpose <string:operator> <image:pic1>
  313.  
  314.         Transpose the top image.
  315.         """
  316.         transpose = string.upper(self.do_pop())
  317.         image = self.do_pop()
  318.         self.push(image.transpose(transpose))
  319.  
  320.     # Image attributes
  321.  
  322.     def do_format(self):
  323.         """usage: format <image:pic1>
  324.  
  325.         Push the format of the top image onto the stack.
  326.         """
  327.         self.push(self.pop().format)
  328.  
  329.     def do_mode(self):
  330.         """usage: mode <image:pic1>
  331.  
  332.         Push the mode of the top image onto the stack.
  333.         """
  334.         self.push(self.pop().mode)
  335.  
  336.     def do_size(self):
  337.         """usage: size <image:pic1>
  338.  
  339.         Push the image size on the stack as (y, x).
  340.         """
  341.         size = self.pop().size
  342.         self.push(size[0])
  343.         self.push(size[1])
  344.  
  345.     # ImageChops operations
  346.  
  347.     def do_invert(self):
  348.         """usage: invert <image:pic1>
  349.  
  350.         Invert the top image.
  351.         """
  352.         import ImageChops
  353.         self.push(ImageChops.invert(self.do_pop()))
  354.  
  355.     def do_lighter(self):
  356.         """usage: lighter <image:pic1> <image:pic2>
  357.  
  358.         Pop the two top images, push an image of the lighter pixels of both.
  359.         """
  360.         import ImageChops
  361.         image1 = self.do_pop()
  362.         image2 = self.do_pop()
  363.         self.push(ImageChops.lighter(image1, image2))
  364.  
  365.     def do_darker(self):
  366.         """usage: darker <image:pic1> <image:pic2>
  367.  
  368.         Pop the two top images, push an image of the darker pixels of both.
  369.         """
  370.         import ImageChops
  371.         image1 = self.do_pop()
  372.         image2 = self.do_pop()
  373.         self.push(ImageChops.darker(image1, image2))
  374.  
  375.     def do_difference(self):
  376.         """usage: difference <image:pic1> <image:pic2>
  377.  
  378.         Pop the two top images, push the difference image
  379.         """
  380.         import ImageChops
  381.         image1 = self.do_pop()
  382.         image2 = self.do_pop()
  383.         self.push(ImageChops.difference(image1, image2))
  384.  
  385.     def do_multiply(self):
  386.         """usage: multiply <image:pic1> <image:pic2>
  387.  
  388.         Pop the two top images, push the multiplication image.
  389.         """
  390.         import ImageChops
  391.         image1 = self.do_pop()
  392.         image2 = self.do_pop()
  393.         self.push(ImageChops.multiply(image1, image2))
  394.  
  395.     def do_screen(self):
  396.         """usage: screen <image:pic1> <image:pic2>
  397.  
  398.         Pop the two top images, superimpose their inverted versions.
  399.         """
  400.         import ImageChops
  401.         image2 = self.do_pop()
  402.         image1 = self.do_pop()
  403.         self.push(ImageChops.screen(image1, image2))
  404.  
  405.     def do_add(self):
  406.         """usage: add <image:pic1> <image:pic2> <int:offset> <float:scale>
  407.  
  408.         Pop the two top images, produce the scaled sum with offset.
  409.         """
  410.         import ImageChops
  411.         image1 = self.do_pop()
  412.         image2 = self.do_pop()
  413.         scale = float(self.do_pop())
  414.         offset = int(self.do_pop())
  415.         self.push(ImageChops.add(image1, image2, scale, offset))
  416.  
  417.     def do_subtract(self):
  418.         """usage: subtract <image:pic1> <image:pic2> <int:offset> <float:scale>
  419.  
  420.         Pop the two top images, produce the scaled difference with offset.
  421.         """
  422.         import ImageChops
  423.         image1 = self.do_pop()
  424.         image2 = self.do_pop()
  425.         scale = float(self.do_pop())
  426.         offset = int(self.do_pop())
  427.         self.push(ImageChops.subtract(image1, image2, scale, offset))
  428.  
  429.     # ImageEnhance classes
  430.  
  431.     def do_color(self):
  432.         """usage: color <image:pic1>
  433.  
  434.         Enhance color in the top image.
  435.         """
  436.         import ImageEnhance
  437.         factor = float(self.do_pop())
  438.         image = self.do_pop()
  439.         enhancer = ImageEnhance.Color(image)
  440.         self.push(enhancer.enhance(factor))
  441.  
  442.     def do_contrast(self):
  443.         """usage: contrast <image:pic1>
  444.  
  445.         Enhance contrast in the top image.
  446.         """
  447.         import ImageEnhance
  448.         factor = float(self.do_pop())
  449.         image = self.do_pop()
  450.         enhancer = ImageEnhance.Color(image)
  451.         self.push(enhancer.enhance(factor))
  452.  
  453.     def do_brightness(self):
  454.         """usage: brightness <image:pic1>
  455.  
  456.         Enhance brightness in the top image.
  457.         """
  458.         import ImageEnhance
  459.         factor = float(self.do_pop())
  460.         image = self.do_pop()
  461.         enhancer = ImageEnhance.Color(image)
  462.         self.push(enhancer.enhance(factor))
  463.  
  464.     def do_sharpness(self):
  465.         """usage: sharpness <image:pic1>
  466.  
  467.         Enhance sharpness in the top image.
  468.         """
  469.         import ImageEnhance
  470.         factor = float(self.do_pop())
  471.         image = self.do_pop()
  472.         enhancer = ImageEnhance.Color(image)
  473.         self.push(enhancer.enhance(factor))
  474.  
  475.     # The interpreter loop
  476.  
  477.     def execute(self, list):
  478.         "Interpret a list of PILDriver commands."
  479.         list.reverse()
  480.         while len(list) > 0:
  481.             self.push(list[0])
  482.             list = list[1:]
  483.             if self.verbose:
  484.                 print "Stack: " + `self.stack`
  485.             top = self.top()
  486.             if type(top) != type(""):
  487.                 continue;
  488.             funcname = "do_" + top
  489.             if not hasattr(self, funcname):
  490.                 continue
  491.             else:
  492.                 self.do_pop()
  493.                 func = getattr(self, funcname)
  494.                 func()
  495.  
  496. if __name__ == '__main__':
  497.     import sys
  498.     try:
  499.         import readline
  500.     except ImportError:
  501.         pass # not available on all platforms
  502.  
  503.     # If we see command-line arguments, interpret them as a stack state
  504.     # and execute.  Otherwise go interactive.
  505.  
  506.     driver = PILDriver()
  507.     if len(sys.argv[1:]) > 0:
  508.         driver.execute(sys.argv[1:])
  509.     else:
  510.         print "PILDriver says hello."
  511.         while 1:
  512.             try:
  513.                 line = raw_input('pildriver> ');
  514.             except EOFError:
  515.                 print "\nPILDriver says goodbye."
  516.                 break
  517.             driver.execute(string.split(line))
  518.             print driver.stack
  519.  
  520. # The following sets edit modes for GNU EMACS
  521. # Local Variables:
  522. # mode:python
  523. # End:
  524.